package h0710;

import java.util.ArrayList;
import java.util.Scanner;
/**
  * @description TODO 堆内存申请
  * @author 不知名帅哥
  * @date 2024/7/10 23:08
  * @version 1.0
*/
public class HeapMemoryApplication {
    static class Memory{
        int offset;
        int size;
        public Memory(int offset, int size) {
            this.offset = offset;
            this.size = size;
        }
    }
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int requestSize = sc.nextInt();
        ArrayList<Memory> used_memory = new ArrayList<>();
        while (sc.hasNextInt()){
            int offset = sc.nextInt();
            int size = sc.nextInt();
            used_memory.add(new Memory(offset,size));
        }

        System.out.println(getResult(used_memory,requestSize));
    }

    private static int getResult(ArrayList<Memory> usedMemory, int requestSize) {
        //申请的内存大小非法，则返回-1
        if (requestSize<=0||requestSize>100){
            return -1;
        }
        //初始化
        int bestOffset=-1; //记录最优的申请内存起始位置
        int minSize=100;

        //按照起始位置升序排序
        usedMemory.sort((a,b)->a.offset-b.offset);

        //初始空闲内存块开始下标。记录（相对于已占用内存的前面一个）空闲内存块的起始位置
        int freeStart=0;
        for (Memory memory : usedMemory) {
            // 如果占用的内存起始位置 小于 前面一个空闲内存块起始位置，则存在占用内存区域重叠
            // 如果占用的内存起始位置 大于 99，则非法
            if (memory.offset>99||memory.offset<freeStart){
                return -1;
            }

            // 如果占用的内存的大小少于0，则非法
            // 如果占用的内存的大小超过该内存起始位置往后所能申请到的最大内存大小，则无效
            if (memory.size<=0||100-memory.offset< memory.size){
                return -1;
            }
            if (memory.offset>freeStart){
                //当前空闲内存大小等于memory块的初始位置减去freeStart。
                int freeSize= memory.offset-freeStart;
                //满足要求。如果该空闲内存块大小足够，且最接近申请的内存大小
                if (freeSize>=requestSize&&freeSize<=minSize){
                    bestOffset=freeStart;
                    minSize=freeSize;
                }
            }
            //更新空闲内存块的起始位置。TODO 空闲内存的起始位置 = （当前占用内存的结束位置 + 1） = （当前占用内存的起始位置 + 占用大小）
            freeStart= memory.offset+ memory.size;
        }
        int last_free_memory_size=100-freeStart;
        if (last_free_memory_size<=minSize&&last_free_memory_size>=requestSize){
            bestOffset=freeStart;
        }
        return bestOffset;
    }
}
